'Weak Dependency Graph [60.0]'
------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 8(4(x1)) -> 6(x1)
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 8(8(4(x1))) -> 1(9(x1))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))}
Details:
We have computed the following set of weak (innermost) dependency pairs:
{ 3^#(1(x1)) -> c_0()
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(4(x1)) -> c_4()
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 7^#(5(x1)) -> c_11()}
The usable rules are:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
The estimated dependency graph contains the following edges:
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
==> {2^#(6(x1)) -> c_5(3^#(x1))}
{3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
==> {8^#(8(4(x1))) -> c_8(9^#(x1))}
{3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
==> {8^#(4(x1)) -> c_4()}
{9^#(x1) -> c_3(3^#(2(3(x1))))}
==> {3^#(9(x1)) -> c_10(9^#(3(x1)))}
{9^#(x1) -> c_3(3^#(2(3(x1))))}
==> {3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
{9^#(x1) -> c_3(3^#(2(3(x1))))}
==> {3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
{9^#(x1) -> c_3(3^#(2(3(x1))))}
==> {3^#(1(x1)) -> c_0()}
{2^#(6(x1)) -> c_5(3^#(x1))}
==> {3^#(9(x1)) -> c_10(9^#(3(x1)))}
{2^#(6(x1)) -> c_5(3^#(x1))}
==> {3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
{2^#(6(x1)) -> c_5(3^#(x1))}
==> {3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
{2^#(6(x1)) -> c_5(3^#(x1))}
==> {3^#(1(x1)) -> c_0()}
{3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
==> {3^#(9(x1)) -> c_10(9^#(3(x1)))}
{3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
==> {3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
{3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
==> {3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
{3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
==> {3^#(1(x1)) -> c_0()}
{8^#(8(4(x1))) -> c_8(9^#(x1))}
==> {9^#(x1) -> c_7(5^#(0(2(x1))))}
{8^#(8(4(x1))) -> c_8(9^#(x1))}
==> {9^#(x1) -> c_3(3^#(2(3(x1))))}
{7^#(1(x1)) -> c_9(9^#(x1))}
==> {9^#(x1) -> c_7(5^#(0(2(x1))))}
{7^#(1(x1)) -> c_9(9^#(x1))}
==> {9^#(x1) -> c_3(3^#(2(3(x1))))}
{3^#(9(x1)) -> c_10(9^#(3(x1)))}
==> {9^#(x1) -> c_7(5^#(0(2(x1))))}
{3^#(9(x1)) -> c_10(9^#(3(x1)))}
==> {9^#(x1) -> c_3(3^#(2(3(x1))))}
We consider the following path(s):
1) { 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
The usable rules for this path are the following:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [3]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [2]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
and weakly orienting the rules
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [2]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [8]
c_0() = [0]
5^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [3]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2^#(6(x1)) -> c_5(3^#(x1))}
and weakly orienting the rules
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2^#(6(x1)) -> c_5(3^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [2]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [8]
c_0() = [0]
5^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [9]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [8]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [9]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [3]
8(x1) = [1] x1 + [4]
7(x1) = [1] x1 + [4]
0(x1) = [1] x1 + [1]
3^#(x1) = [1] x1 + [4]
c_0() = [0]
5^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [2]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [2]
1(x1) = [1] x1 + [3]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [3]
9(x1) = [1] x1 + [2]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [14]
c_0() = [0]
5^#(x1) = [1] x1 + [15]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [13]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [13]
9^#(x1) = [1] x1 + [14]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [2]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9(x1) -> 3(2(3(x1)))}
and weakly orienting the rules
{ 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9(x1) -> 3(2(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [4]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [8]
9(x1) = [1] x1 + [1]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [15]
c_1(x1) = [1] x1 + [4]
2^#(x1) = [1] x1 + [3]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [3]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))}
and weakly orienting the rules
{ 9(x1) -> 3(2(3(x1)))
, 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [3]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [10]
9(x1) = [1] x1 + [2]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [6]
c_0() = [0]
5^#(x1) = [1] x1 + [15]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [7]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [4]
9^#(x1) = [1] x1 + [8]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 9(x1) -> 5(0(2(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 9(x1) -> 3(2(3(x1)))
, 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 9(x1) -> 5(0(2(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 9(x1) -> 3(2(3(x1)))
, 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 21
, 3_0(3) -> 21
, 3_0(7) -> 21
, 3_0(10) -> 21
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(2) -> 21
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 2_0(21) -> 20
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 3^#_0(20) -> 19
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 2^#_0(2) -> 15
, 2^#_0(3) -> 15
, 2^#_0(7) -> 15
, 2^#_0(10) -> 15
, 8^#_0(2) -> 17
, 8^#_0(3) -> 17
, 8^#_0(7) -> 17
, 8^#_0(10) -> 17
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_3_0(19) -> 18
, c_5_0(11) -> 15}
2) { 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))}
The usable rules for this path are the following:
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 9^#(x1) -> c_7(5^#(0(2(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [8]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [7]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7^#(1(x1)) -> c_9(9^#(x1))}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7^#(1(x1)) -> c_9(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [8]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_7(5^#(0(2(x1))))}
and weakly orienting the rules
{ 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_7(5^#(0(2(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [2]
9^#(x1) = [1] x1 + [1]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [3]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
and weakly orienting the rules
{ 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_3(3^#(2(3(x1))))}
and weakly orienting the rules
{ 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_3(3^#(2(3(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [3]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [5]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 9^#(x1) -> c_3(3^#(2(3(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [8]
6(x1) = [1] x1 + [5]
8(x1) = [1] x1 + [9]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [2]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [2]
9^#(x1) = [1] x1 + [12]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [13]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [3]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [1]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [3]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [3]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [3]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [3]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [2]
7^#(x1) = [1] x1 + [9]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{5(9(x1)) -> 2(6(5(x1)))}
and weakly orienting the rules
{ 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{5(9(x1)) -> 2(6(5(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [12]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [3]
6(x1) = [1] x1 + [4]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [5]
0(x1) = [1] x1 + [1]
3^#(x1) = [1] x1 + [6]
c_0() = [0]
5^#(x1) = [1] x1 + [4]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [5]
9^#(x1) = [1] x1 + [13]
c_3(x1) = [1] x1 + [2]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [13]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9(x1) -> 5(0(2(x1)))}
and weakly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9(x1) -> 5(0(2(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
4(x1) = [1] x1 + [9]
5(x1) = [1] x1 + [8]
9(x1) = [1] x1 + [9]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [9]
8(x1) = [1] x1 + [11]
7(x1) = [1] x1 + [3]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [9]
c_0() = [0]
5^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [4]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [10]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [7]
c_8(x1) = [1] x1 + [3]
7^#(x1) = [1] x1 + [13]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [8]
c_0() = [0]
5^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [8]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [3]
c_7(x1) = [1] x1 + [2]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [13]
c_9(x1) = [1] x1 + [2]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [2]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [2]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [4]
c_0() = [0]
5^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [5]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [4]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 7(1(x1)) -> 6(9(x1))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 7(1(x1)) -> 6(9(x1))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 28
, 3_0(3) -> 28
, 3_0(7) -> 28
, 3_0(10) -> 28
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(2) -> 28
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 4_0(28) -> 31
, 2_0(2) -> 31
, 2_0(3) -> 31
, 2_0(7) -> 31
, 2_0(10) -> 31
, 2_0(28) -> 27
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 0_0(31) -> 30
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 3^#_0(27) -> 26
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 5^#_0(30) -> 29
, 8^#_0(2) -> 17
, 8^#_0(3) -> 17
, 8^#_0(7) -> 17
, 8^#_0(10) -> 17
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_3_0(26) -> 18
, c_7_0(29) -> 18
, 7^#_0(2) -> 25
, 7^#_0(3) -> 25
, 7^#_0(7) -> 25
, 7^#_0(10) -> 25
, c_9_0(18) -> 25}
3) { 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(1(x1)) -> c_0()}
The usable rules for this path are the following:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(1(x1)) -> c_0()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [7]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2^#(6(x1)) -> c_5(3^#(x1))}
and weakly orienting the rules
{ 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2^#(6(x1)) -> c_5(3^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [8]
2^#(x1) = [1] x1 + [8]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [9]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
and weakly orienting the rules
{ 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [2]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [2]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [14]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_3(3^#(2(3(x1))))}
and weakly orienting the rules
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_3(3^#(2(3(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [3]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))}
and weakly orienting the rules
{ 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
4(x1) = [1] x1 + [11]
5(x1) = [1] x1 + [14]
9(x1) = [1] x1 + [5]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [2]
8(x1) = [1] x1 + [5]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [5]
c_0() = [0]
5^#(x1) = [1] x1 + [14]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [3]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [8]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [2]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [9]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [9]
4(x1) = [1] x1 + [3]
5(x1) = [1] x1 + [15]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [3]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [7]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [6]
9^#(x1) = [1] x1 + [8]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3^#(9(x1)) -> c_10(9^#(3(x1)))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3^#(9(x1)) -> c_10(9^#(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [6]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [8]
9(x1) = [1] x1 + [1]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [15]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [7]
c_2(x1) = [1] x1 + [6]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [3]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [4]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [12]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [4]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [4]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [2]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 9(x1) -> 5(0(2(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 9(x1) -> 5(0(2(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(1(x1)) -> c_0()}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 21
, 3_0(3) -> 21
, 3_0(7) -> 21
, 3_0(10) -> 21
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(2) -> 21
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 2_0(21) -> 20
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 3^#_0(20) -> 19
, c_0_0() -> 11
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 2^#_0(2) -> 15
, 2^#_0(3) -> 15
, 2^#_0(7) -> 15
, 2^#_0(10) -> 15
, 8^#_0(2) -> 17
, 8^#_0(3) -> 17
, 8^#_0(7) -> 17
, 8^#_0(10) -> 17
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_3_0(19) -> 18
, c_5_0(11) -> 15}
4) { 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
The usable rules for this path are the following:
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [9]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7^#(1(x1)) -> c_9(9^#(x1))}
and weakly orienting the rules
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7^#(1(x1)) -> c_9(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [8]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [2]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [8]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [4]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [2]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [4]
6(x1) = [1] x1 + [8]
8(x1) = [1] x1 + [14]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [5]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [1]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [7]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [8]
8(x1) = [1] x1 + [15]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [8]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [4]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [3]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))}
and weakly orienting the rules
{ 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [3]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [3]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [3]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [3]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [10]
7(x1) = [1] x1 + [4]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [8]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [3]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_3(3^#(2(3(x1))))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_3(3^#(2(3(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [2]
8(x1) = [1] x1 + [13]
7(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [12]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [14]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [15]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [2]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [13]
7(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [14]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [4]
9^#(x1) = [1] x1 + [15]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [15]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 28
, 3_0(3) -> 28
, 3_0(7) -> 28
, 3_0(10) -> 28
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(2) -> 28
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 2_0(28) -> 27
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 3^#_0(27) -> 26
, 8^#_0(2) -> 17
, 8^#_0(3) -> 17
, 8^#_0(7) -> 17
, 8^#_0(10) -> 17
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_3_0(26) -> 18
, 7^#_0(2) -> 25
, 7^#_0(3) -> 25
, 7^#_0(7) -> 25
, 7^#_0(10) -> 25
, c_9_0(18) -> 25}
5) { 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
The usable rules for this path are the following:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 8^#(4(x1)) -> c_4()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [1]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [2]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2^#(6(x1)) -> c_5(3^#(x1))}
and weakly orienting the rules
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2^#(6(x1)) -> c_5(3^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [0]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [5]
2^#(x1) = [1] x1 + [5]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3^#(9(x1)) -> c_10(9^#(3(x1)))}
and weakly orienting the rules
{ 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3^#(9(x1)) -> c_10(9^#(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [4]
c_0() = [0]
5^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [3]
2^#(x1) = [1] x1 + [4]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [5]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [9]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [3]
8(x1) = [1] x1 + [4]
7(x1) = [1] x1 + [3]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [2]
c_0() = [0]
5^#(x1) = [1] x1 + [15]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [2]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [2]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [1]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [12]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [3]
0(x1) = [1] x1 + [7]
3^#(x1) = [1] x1 + [4]
c_0() = [0]
5^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [5]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [9]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [13]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [5]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_3(3^#(2(3(x1))))}
and weakly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_3(3^#(2(3(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [1]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [8]
9(x1) = [1] x1 + [1]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [3]
c_0() = [0]
5^#(x1) = [1] x1 + [12]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [5]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [4]
9^#(x1) = [1] x1 + [4]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [4]
1(x1) = [1] x1 + [11]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [15]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [4]
8(x1) = [1] x1 + [10]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [4]
3^#(x1) = [1] x1 + [4]
c_0() = [0]
5^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [10]
9^#(x1) = [1] x1 + [8]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 9(x1) -> 5(0(2(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 9(x1) -> 5(0(2(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 21
, 3_0(3) -> 21
, 3_0(7) -> 21
, 3_0(10) -> 21
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(2) -> 21
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 2_0(21) -> 20
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 3^#_0(20) -> 19
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 2^#_0(2) -> 15
, 2^#_0(3) -> 15
, 2^#_0(7) -> 15
, 2^#_0(10) -> 15
, 8^#_0(2) -> 17
, 8^#_0(3) -> 17
, 8^#_0(7) -> 17
, 8^#_0(10) -> 17
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_3_0(19) -> 18
, c_4_0() -> 17
, c_5_0(11) -> 15}
6) { 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(1(x1)) -> c_0()}
The usable rules for this path are the following:
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(1(x1)) -> c_0()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [2]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [9]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
and weakly orienting the rules
{ 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [15]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7^#(1(x1)) -> c_9(9^#(x1))}
and weakly orienting the rules
{ 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7^#(1(x1)) -> c_9(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [4]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [1]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [9]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [2]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [14]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [6]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [5]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [10]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [9]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [13]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [8]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_3(3^#(2(3(x1))))}
and weakly orienting the rules
{ 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_3(3^#(2(3(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [8]
8(x1) = [1] x1 + [15]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [8]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [10]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [13]
c_9(x1) = [1] x1 + [3]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(5(x1)) -> 1(0(x1))}
and weakly orienting the rules
{ 9^#(x1) -> c_3(3^#(2(3(x1))))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(5(x1)) -> 1(0(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [2]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [12]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [9]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [12]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [15]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 7(5(x1)) -> 1(0(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [2]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [15]
7(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [2]
3^#(x1) = [1] x1 + [12]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [15]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [15]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [8]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [3]
8(x1) = [1] x1 + [12]
7(x1) = [1] x1 + [7]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [10]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [12]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [2]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [9]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3^#(1(x1)) -> c_0()
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 28
, 3_0(3) -> 28
, 3_0(7) -> 28
, 3_0(10) -> 28
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(2) -> 28
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 2_0(28) -> 27
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 3^#_0(27) -> 26
, c_0_0() -> 11
, 8^#_0(2) -> 17
, 8^#_0(3) -> 17
, 8^#_0(7) -> 17
, 8^#_0(10) -> 17
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_3_0(26) -> 18
, 7^#_0(2) -> 25
, 7^#_0(3) -> 25
, 7^#_0(7) -> 25
, 7^#_0(10) -> 25
, c_9_0(18) -> 25}
7) { 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))}
The usable rules for this path are the following:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 9^#(x1) -> c_7(5^#(0(2(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [5]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(5(x1)) -> 8(9(7(x1)))}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(5(x1)) -> 8(9(7(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [9]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [7]
c_0() = [0]
5^#(x1) = [1] x1 + [8]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))}
and weakly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [9]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [2]
6(x1) = [1] x1 + [3]
8(x1) = [1] x1 + [2]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [8]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [10]
c_2(x1) = [1] x1 + [8]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [9]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [5]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [12]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [8]
9(x1) = [1] x1 + [1]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [7]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [7]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [15]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [3]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [11]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 3(1(x1)) -> 4(1(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [3]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [12]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [3]
6(x1) = [1] x1 + [2]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [14]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [14]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [3]
c_7(x1) = [1] x1 + [4]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 3(1(x1)) -> 4(1(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [6]
9(x1) = [1] x1 + [1]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [7]
c_0() = [0]
5^#(x1) = [1] x1 + [15]
c_1(x1) = [1] x1 + [3]
2^#(x1) = [1] x1 + [7]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [12]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [8]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_3(3^#(2(3(x1))))}
and weakly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(1(x1)) -> 4(1(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_3(3^#(2(3(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [2]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [7]
9(x1) = [1] x1 + [1]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [4]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [10]
c_1(x1) = [1] x1 + [2]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [1]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [2]
c_8(x1) = [1] x1 + [2]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 9(x1) -> 5(0(2(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9^#(x1) -> c_7(5^#(0(2(x1))))}
Weak Rules:
{ 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(1(x1)) -> 4(1(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 9(x1) -> 5(0(2(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9^#(x1) -> c_7(5^#(0(2(x1))))}
Weak Rules:
{ 9^#(x1) -> c_3(3^#(2(3(x1))))
, 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(1(x1)) -> 4(1(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2(6(x1)) -> 4(3(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 21
, 3_0(3) -> 21
, 3_0(7) -> 21
, 3_0(10) -> 21
, 3_1(2) -> 27
, 3_1(3) -> 27
, 3_1(7) -> 27
, 3_1(10) -> 27
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 1_1(2) -> 28
, 1_1(3) -> 28
, 1_1(7) -> 28
, 1_1(10) -> 28
, 4_0(2) -> 3
, 4_0(2) -> 21
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 4_1(27) -> 24
, 4_1(28) -> 27
, 2_0(21) -> 20
, 2_1(2) -> 24
, 2_1(3) -> 24
, 2_1(7) -> 24
, 2_1(10) -> 24
, 2_1(27) -> 26
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 0_1(24) -> 23
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 3^#_0(20) -> 19
, 3^#_1(26) -> 25
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 5^#_1(23) -> 22
, 2^#_0(2) -> 15
, 2^#_0(3) -> 15
, 2^#_0(7) -> 15
, 2^#_0(10) -> 15
, 8^#_0(2) -> 17
, 8^#_0(3) -> 17
, 8^#_0(7) -> 17
, 8^#_0(10) -> 17
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_3_0(19) -> 18
, c_3_1(25) -> 18
, c_5_0(11) -> 15
, c_7_1(22) -> 18}
8) { 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 8^#(4(x1)) -> c_4()}
The usable rules for this path are the following:
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 3(9(x1)) -> 9(3(x1))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 8^#(4(x1)) -> c_4()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [2]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3^#(8(x1)) -> c_6(3^#(2(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7^#(1(x1)) -> c_9(9^#(x1))}
and weakly orienting the rules
{ 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7^#(1(x1)) -> c_9(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [14]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_3(3^#(2(3(x1))))}
and weakly orienting the rules
{ 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_3(3^#(2(3(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
8^#(x1) = [1] x1 + [6]
9^#(x1) = [1] x1 + [7]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [9]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
and weakly orienting the rules
{ 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3^#(5(x1)) -> c_2(8^#(9(7(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [2]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [9]
c_9(x1) = [1] x1 + [6]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [2]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [2]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [2]
9^#(x1) = [1] x1 + [4]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [9]
c_9(x1) = [1] x1 + [5]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 3(1(x1)) -> 4(1(x1))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(1(x1)) -> 4(1(x1))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [15]
9(x1) = [1] x1 + [12]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [13]
8(x1) = [1] x1 + [15]
7(x1) = [1] x1 + [3]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [0]
9^#(x1) = [1] x1 + [15]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [2]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [15]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [2]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))}
and weakly orienting the rules
{ 3(1(x1)) -> 4(1(x1))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 2(6(x1)) -> 4(3(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [9]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [9]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [1]
9^#(x1) = [1] x1 + [11]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
7^#(x1) = [1] x1 + [11]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3(1(x1)) -> 4(1(x1))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 2(6(x1)) -> 4(3(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [7]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [4]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [4]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [3]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [12]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
8^#(x1) = [1] x1 + [9]
9^#(x1) = [1] x1 + [14]
c_3(x1) = [1] x1 + [1]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [2]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
7^#(x1) = [1] x1 + [8]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [1]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 7(1(x1)) -> 6(9(x1))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3(1(x1)) -> 4(1(x1))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 2(6(x1)) -> 4(3(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(5(x1)) -> 8(9(7(x1)))
, 3(9(x1)) -> 9(3(x1))}
Weak Rules:
{ 7(1(x1)) -> 6(9(x1))
, 9(x1) -> 5(0(2(x1)))
, 5(9(x1)) -> 2(6(5(x1)))
, 3^#(9(x1)) -> c_10(9^#(3(x1)))
, 3(1(x1)) -> 4(1(x1))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 2(6(x1)) -> 4(3(x1))
, 3^#(5(x1)) -> c_2(8^#(9(7(x1))))
, 9^#(x1) -> c_3(3^#(2(3(x1))))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3^#(8(x1)) -> c_6(3^#(2(7(x1))))
, 3(8(x1)) -> 3(2(7(x1)))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 8^#(8(4(x1))) -> c_8(9^#(x1))
, 8^#(4(x1)) -> c_4()}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 28
, 3_0(3) -> 28
, 3_0(7) -> 28
, 3_0(10) -> 28
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(2) -> 28
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 2_0(28) -> 27
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 3^#_0(27) -> 26
, 8^#_0(2) -> 17
, 8^#_0(3) -> 17
, 8^#_0(7) -> 17
, 8^#_0(10) -> 17
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_3_0(26) -> 18
, c_4_0() -> 17
, 7^#_0(2) -> 25
, 7^#_0(3) -> 25
, 7^#_0(7) -> 25
, 7^#_0(10) -> 25
, c_9_0(18) -> 25}
9) { 7^#(1(x1)) -> c_9(9^#(x1))
, 9^#(x1) -> c_7(5^#(0(2(x1))))}
The usable rules for this path are the following:
{ 2(6(x1)) -> 4(3(x1))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 5(9(x1)) -> 2(6(5(x1)))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 2(6(x1)) -> 4(3(x1))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 9^#(x1) -> c_7(5^#(0(2(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{9^#(x1) -> c_7(5^#(0(2(x1))))}
and weakly orienting the rules
{ 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{9^#(x1) -> c_7(5^#(0(2(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(8(x1)) -> 3(2(7(x1)))}
and weakly orienting the rules
{ 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(8(x1)) -> 3(2(7(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [9]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7^#(1(x1)) -> c_9(9^#(x1))}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7^#(1(x1)) -> c_9(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [0]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [9]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))}
and weakly orienting the rules
{ 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [4]
9(x1) = [1] x1 + [2]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [4]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [9]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [2]
4(x1) = [1] x1 + [9]
5(x1) = [1] x1 + [2]
9(x1) = [1] x1 + [1]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [8]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [12]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [13]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [5]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [10]
9(x1) = [1] x1 + [2]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [8]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [10]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [4]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [13]
9(x1) = [1] x1 + [4]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [4]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [3]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [4]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [0]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 5(0(2(x1)))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 5(0(2(x1)))}
Weak Rules:
{ 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 9(x1) -> 3(2(3(x1)))
, 7(5(x1)) -> 1(0(x1))
, 5(9(x1)) -> 2(6(5(x1)))
, 7^#(1(x1)) -> c_9(9^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 9^#(x1) -> c_7(5^#(0(2(x1))))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 3_0(2) -> 29
, 3_0(3) -> 29
, 3_0(7) -> 29
, 3_0(10) -> 29
, 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(2) -> 29
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 4_0(29) -> 28
, 2_0(2) -> 28
, 2_0(3) -> 28
, 2_0(7) -> 28
, 2_0(10) -> 28
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 0_0(28) -> 27
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 5^#_0(27) -> 26
, 9^#_0(2) -> 18
, 9^#_0(3) -> 18
, 9^#_0(7) -> 18
, 9^#_0(10) -> 18
, c_7_0(26) -> 18
, 7^#_0(2) -> 25
, 7^#_0(3) -> 25
, 7^#_0(7) -> 25
, 7^#_0(10) -> 25
, c_9_0(18) -> 25}
10)
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3^#(1(x1)) -> c_0()}
The usable rules for this path are the following:
{ 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 3^#(1(x1)) -> c_0()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [2]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [3]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2^#(6(x1)) -> c_5(3^#(x1))}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2^#(6(x1)) -> c_5(3^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
and weakly orienting the rules
{ 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(5(x1)) -> 8(9(7(x1)))}
and weakly orienting the rules
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(5(x1)) -> 8(9(7(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [0]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2(6(x1)) -> 4(3(x1))}
and weakly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2(6(x1)) -> 4(3(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [1]
c_0() = [0]
5^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [11]
2^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 2(6(x1)) -> 4(3(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [1]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [1]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))}
and weakly orienting the rules
{ 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [2]
4(x1) = [1] x1 + [0]
5(x1) = [1] x1 + [15]
9(x1) = [1] x1 + [2]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [1]
8(x1) = [1] x1 + [2]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [8]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [15]
c_1(x1) = [1] x1 + [1]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 5(0(2(x1)))}
Weak Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 5(0(2(x1)))}
Weak Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 3(2(3(x1)))
, 3(1(x1)) -> 4(1(x1))
, 2(6(x1)) -> 4(3(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 3^#(1(x1)) -> c_0()}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, c_0_0() -> 11
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 2^#_0(2) -> 15
, 2^#_0(3) -> 15
, 2^#_0(7) -> 15
, 2^#_0(10) -> 15
, c_5_0(11) -> 15}
11)
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))}
The usable rules for this path are the following:
{ 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{2^#(6(x1)) -> c_5(3^#(x1))}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{2^#(6(x1)) -> c_5(3^#(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [8]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
and weakly orienting the rules
{ 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(5(x1)) -> 8(9(7(x1)))}
and weakly orienting the rules
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(5(x1)) -> 8(9(7(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [0]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [1]
4(x1) = [1] x1 + [9]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [0]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [3]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 5(0(2(x1)))}
and weakly orienting the rules
{ 3(1(x1)) -> 4(1(x1))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 5(0(2(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [10]
1(x1) = [1] x1 + [6]
4(x1) = [1] x1 + [10]
5(x1) = [1] x1 + [5]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [2]
7(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
3^#(x1) = [1] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [8]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [4]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 2(6(x1)) -> 4(3(x1))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))}
Weak Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 5(0(2(x1)))
, 3(1(x1)) -> 4(1(x1))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 2(6(x1)) -> 4(3(x1))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))}
Weak Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 5(0(2(x1)))
, 3(1(x1)) -> 4(1(x1))
, 7(1(x1)) -> 6(9(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 2^#(6(x1)) -> c_5(3^#(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 3^#_0(2) -> 11
, 3^#_0(3) -> 11
, 3^#_0(7) -> 11
, 3^#_0(10) -> 11
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 2^#_0(2) -> 15
, 2^#_0(3) -> 15
, 2^#_0(7) -> 15
, 2^#_0(10) -> 15
, c_5_0(11) -> 15}
12)
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
The usable rules for this path are the following:
{ 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 2(6(x1)) -> 4(3(x1))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 3(8(x1)) -> 3(2(7(x1)))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))
, 9(x1) -> 5(0(2(x1)))
, 7(1(x1)) -> 6(9(x1))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{7(1(x1)) -> 6(9(x1))}
and weakly orienting the rules
{ 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7(1(x1)) -> 6(9(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [9]
7(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
and weakly orienting the rules
{ 7(1(x1)) -> 6(9(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{5^#(9(x1)) -> c_1(2^#(6(5(x1))))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(5(x1)) -> 8(9(7(x1)))}
and weakly orienting the rules
{ 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(5(x1)) -> 8(9(7(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [0]
7(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{3(1(x1)) -> 4(1(x1))}
and weakly orienting the rules
{ 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{3(1(x1)) -> 4(1(x1))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
4(x1) = [1] x1 + [1]
5(x1) = [1] x1 + [1]
9(x1) = [1] x1 + [0]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [1]
7(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 5(0(2(x1)))}
and weakly orienting the rules
{ 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 5(0(2(x1)))}
Details:
Interpretation Functions:
3(x1) = [1] x1 + [10]
1(x1) = [1] x1 + [8]
4(x1) = [1] x1 + [10]
5(x1) = [1] x1 + [5]
9(x1) = [1] x1 + [8]
2(x1) = [1] x1 + [0]
6(x1) = [1] x1 + [0]
8(x1) = [1] x1 + [3]
7(x1) = [1] x1 + [3]
0(x1) = [1] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
2^#(x1) = [1] x1 + [4]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 2(6(x1)) -> 4(3(x1))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))}
Weak Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 5(0(2(x1)))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 2(6(x1)) -> 4(3(x1))
, 3(9(x1)) -> 9(3(x1))
, 9(x1) -> 3(2(3(x1)))}
Weak Rules:
{ 5(9(x1)) -> 2(6(5(x1)))
, 9(x1) -> 5(0(2(x1)))
, 3(1(x1)) -> 4(1(x1))
, 3(5(x1)) -> 8(9(7(x1)))
, 5^#(9(x1)) -> c_1(2^#(6(5(x1))))
, 7(1(x1)) -> 6(9(x1))
, 3(8(x1)) -> 3(2(7(x1)))
, 7(5(x1)) -> 1(0(x1))
, 8(4(x1)) -> 6(x1)
, 8(8(4(x1))) -> 1(9(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(2) -> 2
, 1_0(3) -> 2
, 1_0(7) -> 2
, 1_0(10) -> 2
, 4_0(2) -> 3
, 4_0(3) -> 3
, 4_0(7) -> 3
, 4_0(10) -> 3
, 6_0(2) -> 7
, 6_0(3) -> 7
, 6_0(7) -> 7
, 6_0(10) -> 7
, 0_0(2) -> 10
, 0_0(3) -> 10
, 0_0(7) -> 10
, 0_0(10) -> 10
, 5^#_0(2) -> 13
, 5^#_0(3) -> 13
, 5^#_0(7) -> 13
, 5^#_0(10) -> 13
, 2^#_0(2) -> 15
, 2^#_0(3) -> 15
, 2^#_0(7) -> 15
, 2^#_0(10) -> 15}
13)
{7^#(1(x1)) -> c_9(9^#(x1))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
3(x1) = [0] x1 + [0]
1(x1) = [0] x1 + [0]
4(x1) = [0] x1 + [0]
5(x1) = [0] x1 + [0]
9(x1) = [0] x1 + [0]
2(x1) = [0] x1 + [0]
6(x1) = [0] x1 + [0]
8(x1) = [0] x1 + [0]
7(x1) = [0] x1 + [0]
0(x1) = [0] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {7^#(1(x1)) -> c_9(9^#(x1))}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{7^#(1(x1)) -> c_9(9^#(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7^#(1(x1)) -> c_9(9^#(x1))}
Details:
Interpretation Functions:
3(x1) = [0] x1 + [0]
1(x1) = [1] x1 + [0]
4(x1) = [0] x1 + [0]
5(x1) = [0] x1 + [0]
9(x1) = [0] x1 + [0]
2(x1) = [0] x1 + [0]
6(x1) = [0] x1 + [0]
8(x1) = [0] x1 + [0]
7(x1) = [0] x1 + [0]
0(x1) = [0] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {7^#(1(x1)) -> c_9(9^#(x1))}
Details:
The given problem does not contain any strict rules
14)
{7^#(5(x1)) -> c_11()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
3(x1) = [0] x1 + [0]
1(x1) = [0] x1 + [0]
4(x1) = [0] x1 + [0]
5(x1) = [0] x1 + [0]
9(x1) = [0] x1 + [0]
2(x1) = [0] x1 + [0]
6(x1) = [0] x1 + [0]
8(x1) = [0] x1 + [0]
7(x1) = [0] x1 + [0]
0(x1) = [0] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {7^#(5(x1)) -> c_11()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{7^#(5(x1)) -> c_11()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{7^#(5(x1)) -> c_11()}
Details:
Interpretation Functions:
3(x1) = [0] x1 + [0]
1(x1) = [0] x1 + [0]
4(x1) = [0] x1 + [0]
5(x1) = [1] x1 + [0]
9(x1) = [0] x1 + [0]
2(x1) = [0] x1 + [0]
6(x1) = [0] x1 + [0]
8(x1) = [0] x1 + [0]
7(x1) = [0] x1 + [0]
0(x1) = [0] x1 + [0]
3^#(x1) = [0] x1 + [0]
c_0() = [0]
5^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
2^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
8^#(x1) = [0] x1 + [0]
9^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
7^#(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {7^#(5(x1)) -> c_11()}
Details:
The given problem does not contain any strict rules